home *** CD-ROM | disk | FTP | other *** search
/ Internet Info 1994 March / Internet Info CD-ROM (Walnut Creek) (March 1994).iso / networking / terms / kermit / c / winh19.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-10-19  |  8.4 KB  |  423 lines
  1. /*
  2.  * Windows H19 Terminal Emulator
  3.  * 
  4.  * Written by William S. Hall
  5.  *          3665 Benton Street, #66
  6.  *          Santa Clara, CA 95051
  7.  *
  8.  * Program entry module
  9.  */
  10.  
  11. #define NOKANJI
  12. #define NOATOM
  13. #include <windows.h>
  14. #include <string.h>
  15.  
  16. #define EXTERN
  17. #define INITIALIZE
  18.  
  19. #include "winasc.h"
  20. #include "winh19.h"
  21. #include "win19d.h"
  22.  
  23. #if defined(KERMIT)
  24. #include "winkpf.h"
  25. extern krmState;
  26. #endif
  27.  
  28. static BOOL NEAR OutputKeydown(BYTE str[], int *plen, WORD wparam);
  29. static void NEAR ScanForEscapes(BYTE *str, int *len);
  30. static void NEAR SetScrollState(void);
  31.  
  32. /* Entry point */
  33. int FAR PASCAL WinMain(hInstance, hPrevInstance, lpszCmdLine, cmdShow)
  34. HANDLE hInstance, hPrevInstance;
  35. LPSTR lpszCmdLine;
  36. short cmdShow;
  37. {
  38.  
  39.     if (!InitProgram(hInstance,hPrevInstance, lpszCmdLine, cmdShow))
  40.     return FALSE;
  41.  
  42.     while (TRUE)
  43.     if (!DoMessage())
  44.         ProcessComm();
  45. }
  46.  
  47. /* Main window procedure */
  48. long FAR PASCAL MainWndProc(hWnd,message,wParam,lParam)
  49. HWND hWnd;
  50. unsigned message;
  51. WORD wParam;
  52. LONG lParam;
  53. {
  54.  
  55.     PAINTSTRUCT ps;
  56.  
  57.     switch(message) {
  58.  
  59.        case WM_CHANGECBCHAIN:
  60.         if (wParam == hWndNext)
  61.         hWndNext = LOWORD(lParam);
  62.         SendMessage(hWndNext, message, wParam, lParam);
  63.         break;
  64.  
  65.     case WM_DRAWCLIPBOARD:
  66.         if (IsWindow(hWndNext))
  67.         SendMessage(hWndNext, message, wParam, lParam);
  68.         if (OpenClipboard(hWnd)) {
  69.         HMENU hMenu = GetMenu(hWnd);
  70.         hClipData = GetClipboardData(CF_TEXT);
  71.         if (hClipData != NULL)
  72.             EnableMenuItem(hMenu, IDM_PASTE, MF_ENABLED);
  73.         else
  74.             EnableMenuItem(hMenu, IDM_PASTE, MF_GRAYED);
  75.         CloseClipboard();
  76.         }
  77.         break;
  78.  
  79.     case WM_CREATE:
  80.         MainWndCreate(hWnd,lParam);
  81.         break;
  82.  
  83.     case WM_KEYDOWN:
  84.         if (!CD.KeyboardDisabled)
  85.             H19LocalKeyDown(wParam);
  86.         break;
  87.  
  88.     case WM_CHAR:
  89.         if (!CD.KeyboardDisabled)
  90.             H19StringInput((BYTE *)&wParam,(short)1);
  91.         break;
  92.  
  93.     case WM_SETFOCUS:
  94.         CD.OwnCaret = TRUE;
  95.         if (IsWindowEnabled(hWnd) && IsWindow(hWndActive)) {
  96.         SendMessage(hWndActive, WH19_CARETFUNCTION, H19_CREATECARET,
  97.                 (LONG)CD.OwnCaret);
  98.         }
  99.         break;
  100.  
  101.     case WM_KILLFOCUS:
  102.         if (IsWindow(hWndActive)) {
  103.         SendMessage(hWndActive,WH19_CARETFUNCTION,H19_DESTROYCARET,
  104.                 (LONG)CD.OwnCaret);
  105.         }
  106.         CD.OwnCaret = FALSE;
  107.         break;
  108.  
  109.     case WM_COMMAND:
  110.         WndCommand(hWnd, wParam, lParam);
  111.         break;
  112.  
  113.     case WM_MOVE:
  114.         MW.SCTopTextLine = HIWORD(lParam);
  115.         MW.SCBottomTextLine = MW.SCTopTextLine + MW.BottomTextLine;
  116.         break;
  117.  
  118.     case WM_SIZE:
  119.         SizeWindow(LOWORD(lParam), HIWORD(lParam), wParam);
  120.         break;
  121.  
  122.     case WM_CLOSE:
  123.         CloseCommPort(hWnd, &cid);
  124.         ChangeClipboardChain(hWnd, hWndNext);
  125.         DestroyWindow(hWnd);
  126.         break;
  127.  
  128.     case WM_ENDSESSION:
  129.         if (wParam)
  130.             CloseCommPort(hWnd, &cid);
  131.         break;
  132.  
  133.     case WM_DESTROY:
  134.         PostQuitMessage(0);
  135.         break;
  136.  
  137.     case WM_PAINT:
  138.         BeginPaint(hWnd, (LPPAINTSTRUCT)&ps);
  139.         MainWndPaint(hWnd, ps.hdc);
  140.         EndPaint(hWnd, (LPPAINTSTRUCT)&ps);
  141.         break;
  142.  
  143.     case WM_SYSCOMMAND:
  144.             return((long)MainSysCommand(hWnd, message, wParam,lParam));
  145.  
  146.     default:
  147.         return ((long)DefWindowProc(hWnd,message,wParam,lParam));
  148.     }
  149.     return(0L);
  150. }
  151.  
  152. /* Subclass window procedure */
  153. LONG FAR PASCAL MainWndSubclassProc(hWnd, message, wParam, lParam)
  154. HWND hWnd;
  155. unsigned message;
  156. WORD wParam;
  157. LONG lParam;
  158. {
  159.  
  160.     BYTE outstr[80];
  161.     int len = 0;
  162.     register BOOL CheckForControl = FALSE;
  163.  
  164.     switch(message) {
  165.  
  166.     case WM_CHAR:
  167. #if defined(KERMIT)
  168.         if (!(CD.KeyboardDisabled || krmState))
  169. #else
  170.         if (!CD.KeyboardDisabled)
  171. #endif
  172.             outstr[len++] = (BYTE)wParam;
  173.             break;
  174.  
  175.     case WM_KEYDOWN:
  176.         if (wParam == VK_CANCEL) {
  177.         if (CD.BreakFlag == -1)
  178.             CD.BreakFlag = SetCommBreak(cid);
  179.              break;
  180.         }
  181.         else if (wParam == VK_SCROLL) {
  182.         SetScrollState();
  183.         break;
  184.         }
  185.  
  186. #if defined(KERMIT)
  187.         if (!(CD.KeyboardDisabled || krmState)) {
  188. #else
  189.         if (!CD.KeyboardDisabled) {
  190. #endif
  191.         switch(wParam) {
  192.  
  193.             case VK_BACK:
  194.             if (GetKeyState(VK_CONTROL) & 0x8000)
  195.                 outstr[len++] = DEL;
  196.             break;
  197.  
  198.             default:
  199.             CheckForControl = OutputKeydown(outstr, &len, wParam);
  200.             break;
  201.         }
  202.         }
  203.         break;        
  204.  
  205.        case WM_COMMAND:
  206.         if ((wParam >= IDM_F1) && (wParam <= IDM_CSF12)) {
  207. #if defined(KERMIT)
  208.             if (!(CD.KeyboardDisabled || krmState)) {
  209. #else
  210.             if (!CD.KeyboardDisabled) {
  211. #endif
  212.             char *tptr;
  213.             int sparam, index;
  214.             sparam = (wParam /100) * 100;
  215.             index = wParam - sparam;
  216.             switch (sparam) {
  217.                 case IDM_F1:
  218.                 tptr = szFKey[index];
  219.                     break;
  220.                 case IDM_SF1:
  221.                 tptr = szSFKey[index];
  222.                      break;
  223.             case IDM_CF1:
  224.                 tptr = szCFKey[index];
  225.                     break;
  226.                 case IDM_CSF1:
  227.                 tptr = szCSFKey[index];
  228.                 break;
  229.             }
  230.                 len = GetProfileString((LPSTR)szAppName,(LPSTR)tptr,
  231.                             (LPSTR)"",(LPSTR)outstr,80);
  232.             ScanForEscapes(outstr, &len);
  233.             break;        
  234.         }
  235.         break;
  236.         }
  237.         return(CallWindowProc(fpTerminal,hWnd,message,wParam,lParam));
  238.  
  239.     case WM_KEYUP:
  240.         if (wParam == VK_CANCEL) {
  241.                 ClearCommBreak(cid);
  242.         CD.BreakFlag = -1;
  243.         break;
  244.         }
  245.  
  246.     default:
  247.         return(CallWindowProc(fpTerminal,hWnd,message,wParam,lParam));
  248.     }
  249.     if (CheckForControl)
  250.     if (GetKeyState(VK_CONTROL) & 0x8000)
  251.         return(CallWindowProc(fpTerminal,hWnd,message,wParam,lParam));
  252.     if (len) {
  253.     WriteToPort(cid, (BYTE FAR *)outstr, len);
  254.     if (!CD.FullDuplex)
  255.         return(CallWindowProc(fpTerminal,hWnd,message,wParam,lParam));
  256.     }
  257.     return 0L;
  258. }
  259.  
  260. static BOOL NEAR OutputKeydown(BYTE str[], int *plen, WORD wparam)
  261. {
  262.  
  263.     register BOOL result = FALSE;
  264.     register int index;
  265.  
  266.     str[(*plen)++] = ESC;
  267.     if (CD.ANSIMode)
  268.     str[(*plen)++] = '[';
  269.  
  270.     switch(wparam) {
  271.         case VK_UP:
  272.         str[(*plen)++] = 'A';
  273.         result = TRUE;            
  274.         break;
  275.         case VK_DOWN:
  276.         str[(*plen)++] = 'B';
  277.         result = TRUE;            
  278.         break;
  279.     case VK_RIGHT:
  280.         str[(*plen)++] = 'C';
  281.         result = TRUE;            
  282.         break;
  283.     case VK_LEFT:
  284.         str[(*plen)++] = 'D';
  285.         result = TRUE;            
  286.         break;
  287.     case VK_HOME:
  288.         if (CD.ANSIMode) {
  289.         str[(*plen)++] = '4';
  290.             if (CD.ICToggle)
  291.             str[(*plen)++] = 'l';
  292.             else
  293.             str[(*plen)++] = 'h';
  294.         }
  295.         else {
  296.             if (CD.ICToggle)
  297.             str[(*plen)++] = 'O';
  298.             else
  299.             str[(*plen)++] = '@';
  300.         }
  301.         result = TRUE;
  302.         break;
  303.     case VK_END:
  304.         str[(*plen)++] = 'L';
  305.         result = TRUE;            
  306.         break;
  307.     case VK_PRIOR:
  308.         if (CD.ANSIMode)
  309.             str[(*plen)++] = 'P';
  310.         else
  311.             str[(*plen)++] = 'N';
  312.         result = TRUE;
  313.         break;
  314.     case VK_NEXT:
  315.         str[(*plen)++] = 'M';
  316.         result = TRUE;            
  317.         break;
  318.     case VK_CLEAR:
  319.         str[(*plen)++] = 'H';
  320.         result = TRUE;            
  321.         break;
  322.  
  323.     case VK_F1:
  324.     case VK_F2:
  325.     case VK_F3:
  326.     case VK_F4:
  327.     case VK_F5:
  328.     case VK_F7:
  329.     case VK_F8:
  330.     case VK_F9:
  331.         if (wparam >= VK_F7)
  332.             index = 'P' + wparam - VK_F7;
  333.         else
  334.             index = 'S' + wparam - VK_F1;
  335.         if (CD.ANSIMode)
  336.             str[*plen - 1] = 'O';
  337.         str[(*plen)++] = (BYTE)index;
  338.         break;
  339.  
  340.     case VK_F6:
  341.         if (GetKeyState(VK_SHIFT) & 0x8000) {
  342.         if (CD.ANSIMode) {
  343.              str[(*plen)++] = '2';
  344.              str[(*plen)++] = 'J';
  345.         }
  346.         else
  347.             str[(*plen)++] = 'E';
  348.         }
  349.         else
  350.             str[(*plen)++] = 'J';
  351.         result = TRUE;
  352.         break;
  353.  
  354.     case VK_NUMPAD0:
  355.     case VK_NUMPAD1:
  356.     case VK_NUMPAD2:
  357.     case VK_NUMPAD3:
  358.     case VK_NUMPAD4:
  359.     case VK_NUMPAD5:
  360.     case VK_NUMPAD6:
  361.     case VK_NUMPAD7:
  362.     case VK_NUMPAD8:
  363.     case VK_NUMPAD9:
  364.     case VK_DECIMAL:
  365.         if (CD.AltKeypad) {
  366.         if (CD.ANSIMode)
  367.             str[*plen - 1] = 'O';
  368.         else
  369.             str[(*plen)++] = '?';
  370.         if (wparam == VK_DECIMAL)
  371.             str[(*plen)++] = 'n';
  372.         else
  373.                 str[(*plen)++] = (BYTE)('p' + (wparam - VK_NUMPAD0));
  374.         }
  375.         else
  376.         *plen = 0;
  377.         break;
  378.     default:
  379.         *plen = 0;
  380.         break;
  381.     }
  382.     return(result);
  383. }
  384.  
  385. static void NEAR ScanForEscapes(BYTE *str, int *len)
  386. {
  387.  
  388.      register int i, j;
  389.      int inlen = min(*len, 79);
  390.      BYTE buf[80], ch;
  391.  
  392.      for (i = 0, j = 0; i < inlen; i++) {
  393.     if ((ch = str[i]) == '\\') {
  394.         ch = str[++i];
  395.         if (('@' <= ch) && (ch <= '['))
  396.         ch ^= 64;
  397.     }
  398.     buf[j++] = ch;
  399.      }
  400.      buf[j] = NUL;
  401.      strcpy(str, buf);
  402.      *len = j;
  403. }
  404.  
  405. static void NEAR SetScrollState()
  406. {
  407.  
  408.     CD.ScrollLock = GetKeyState(VK_SCROLL) & 1;
  409.     if (GetKeyState(VK_SHIFT) & 0x8000)
  410.     CD.ReleaseCount = TW.MaxLines - 1;
  411.     else
  412.     CD.ReleaseCount = 0;
  413.  
  414. }
  415.  
  416. void BroadcastWinIniChange()
  417. {
  418.  
  419.     SendMessage((HWND)-1, WM_WININICHANGE, 0, (LONG)(LPSTR)szAppName);
  420.  
  421. }
  422.  
  423.